public static final Object Exit = new Integer(1);

    public static final Object NoExit = null;

    public static final int GET = 0;

    public static final int SET = 1;

    public static final int DEL = 2;

    public static final int AUGGET = 3;

    public static final int AUGSET = 4;

    public Module module;

    public Code code;

    public ConstantPool pool;

    public CodeCompiler mrefs;

    public CompilerFlags cflags;

    int temporary;

    int augmode;

    int augtmp1;

    int augtmp2;

    int augtmp3;

    int augtmp4;

    public boolean fast_locals, print_results;

    public Hashtable tbl;

    public ScopeInfo my_scope;

    boolean optimizeGlobals = true;

    public Vector names;

    public String className;

    public Stack continueLabels, breakLabels;

    public Stack exceptionHandlers;

    public Vector yields = new Vector();

    /* break/continue finally's level.

     * This is the lowest level in the exceptionHandlers which should

     * be executed at break or continue.

     * It is saved/updated/restored when compiling loops.

     * A similar level for returns is not needed because a new CodeCompiler

     * is used for each PyCode, ie. each 'function'.

     * When returning through finally's all the exceptionHandlers are executed.

     */

    public int bcfLevel = 0;

    public CodeCompiler(Module module, boolean print_results) {

        this.module = module;

        this.print_results = print_results;

        mrefs = this;

        pool = module.classfile.pool;

        continueLabels = new Stack();

        breakLabels = new Stack();

        exceptionHandlers = new Stack();

    }

    public int PyNone;

    public void getNone() throws IOException {

        if (mrefs.PyNone == 0) {

            mrefs.PyNone = pool.Fieldref("org/python/core/Py", "None", $pyObj);

        }

        code.getstatic(mrefs.PyNone);

    }

    public void loadFrame() throws Exception {

        code.aload(1);

    }

    int f_lasti;

    public void setLastI(int idx) throws Exception {

        if (mrefs.f_lasti == 0) {

            mrefs.f_lasti = code.pool.Fieldref("org/python/core/PyFrame", "f_lasti", "I");

        }

        loadFrame();

        code.iconst(idx);

        code.putfield(mrefs.f_lasti);

    }

    int f_back;

    private void loadf_back() throws Exception {

        if (mrefs.f_back == 0) {

            mrefs.f_back = code.pool.Fieldref("org/python/core/PyFrame", "f_back", $pyFrame);

        }

        code.getfield(f_back);

    }

    public int storeTop() throws Exception {

        int tmp = code.getLocal("org/python/core/PyObject");

        code.astore(tmp);

        return tmp;

    }

    public int setline;

    public void setline(int line) throws Exception {

        //System.out.println("line: "+line+", "+code.stack);

        if (module.linenumbers) {

            code.setline(line);

            loadFrame();

            code.iconst(line);

            if (mrefs.setline == 0) {

                mrefs.setline = pool.Methodref("org/python/core/PyFrame", "setline", "(I)V");

            }

            code.invokevirtual(mrefs.setline);

        }

    }

    public void setline(SimpleNode node) throws Exception {

        setline(node.beginLine);

    }

    public void set(SimpleNode node) throws Exception {

        int tmp = storeTop();

        set(node, tmp);

        code.aconst_null();

        code.astore(tmp);

        code.freeLocal(tmp);

    }

    boolean inSet = false;

    public void set(SimpleNode node, int tmp) throws Exception {

        //System.out.println("tmp: "+tmp);

        if (inSet) {

            System.out.println("recurse set: " + tmp + ", " + temporary);

        }

        temporary = tmp;

        visit(node);

    }

    private void saveAugTmps(SimpleNode node, int count) throws Exception {

        if (count >= 4) {

            augtmp4 = code.getLocal("org/python/core/PyObject");

            code.astore(augtmp4);

        }

        if (count >= 3) {

            augtmp3 = code.getLocal("org/python/core/PyObject");

            code.astore(augtmp3);

        }

        if (count >= 2) {

            augtmp2 = code.getLocal("org/python/core/PyObject");

            code.astore(augtmp2);

        }

        augtmp1 = code.getLocal("org/python/core/PyObject");

        code.astore(augtmp1);

        code.aload(augtmp1);

        if (count >= 2)

            code.aload(augtmp2);

        if (count >= 3)

            code.aload(augtmp3);

        if (count >= 4)

            code.aload(augtmp4);

    }

    private void restoreAugTmps(SimpleNode node, int count) throws Exception {

        code.aload(augtmp1);

        code.freeLocal(augtmp1);

        if (count == 1)

            return;

        code.aload(augtmp2);

        code.freeLocal(augtmp2);

        if (count == 2)

            return;

        code.aload(augtmp3);

        code.freeLocal(augtmp3);

        if (count == 3)

            return;

        code.aload(augtmp4);

        code.freeLocal(augtmp4);

    }

    public void parse(modType node, Code code, boolean fast_locals, String className, boolean classBody,

            ScopeInfo scope, CompilerFlags cflags) throws Exception {

        this.fast_locals = fast_locals;

        this.className = className;

        this.code = code;

        this.cflags = cflags;

        my_scope = scope;

        names = scope.names;

        tbl = scope.tbl;

        optimizeGlobals = fast_locals && !scope.exec && !scope.from_import_star;

        Object exit = visit(node);

        //System.out.println("exit: "+exit+", "+(exit==null));

        if (classBody) {

            loadFrame();

            code.invokevirtual("org/python/core/PyFrame", "getf_locals", "()" + $pyObj);

            code.areturn();

        } else {

            if (exit == null) {

                //System.out.println("no exit");

                setLastI(-1);

                getNone();

                code.areturn();

            }

        }

    }

    public Object visitInteractive(Interactive node) throws Exception {

        traverse(node);

        return null;

    }

    public Object visitModule(org.python.parser.ast.Module suite) throws Exception {

        if (mrefs.setglobal == 0) {

            mrefs.setglobal = code.pool.Methodref("org/python/core/PyFrame", "setglobal", "(" + $str + $pyObj + ")V");

        }

        if (suite.body.length > 0 && suite.body[0] instanceof Expr && ((Expr) suite.body[0]).value instanceof Str) {

            loadFrame();

            code.ldc("__doc__");

            visit(((Expr) suite.body[0]).value);

            code.invokevirtual(mrefs.setglobal);

        }

        if (module.setFile) {

            loadFrame();

            code.ldc("__file__");

            module.filename.get(code);

            code.invokevirtual(mrefs.setglobal);

        }

        traverse(suite);

        return null;

    }

    public Object visitExpression(Expression node) throws Exception {

        if (my_scope.generator && node.body != null) {

            module.error("'return' with argument inside generator", true, node);

        }

        return visitReturn(new Return(node.body, node), true);

    }

    public int EmptyObjects;

    public void makeArray(SimpleNode[] nodes) throws Exception {

        int n;

        if (nodes == null)

            n = 0;

        else

            n = nodes.length;

        if (n == 0) {

            if (mrefs.EmptyObjects == 0) {

                mrefs.EmptyObjects = code.pool.Fieldref("org/python/core/Py", "EmptyObjects", $pyObjArr);

            }

            code.getstatic(mrefs.EmptyObjects);

        } else {

            int tmp = code.getLocal("[org/python/core/PyObject");

            code.iconst(n);

            code.anewarray(code.pool.Class("org/python/core/PyObject"));

            code.astore(tmp);

            for (int i = 0; i < n; i++) {

                code.aload(tmp);

                code.iconst(i);

                visit(nodes[i]);

                code.aastore();

            }

            code.aload(tmp);

            code.freeLocal(tmp);

        }

    }

    public void getDocString(stmtType[] suite) throws Exception {

        //System.out.println("doc: "+suite.getChild(0));

        if (suite.length > 0 && suite[0] instanceof Expr && ((Expr) suite[0]).value instanceof Str) {

            visit(((Expr) suite[0]).value);

        } else {

            code.aconst_null();

        }

    }

    int getclosure;

    public boolean makeClosure(ScopeInfo scope) throws Exception {

        if (scope == null || scope.freevars == null)

            return false;

        int n = scope.freevars.size();

        if (n == 0)

            return false;

        if (mrefs.getclosure == 0) {

            mrefs.getclosure = code.pool.Methodref("org/python/core/PyFrame", "getclosure", "(I)" + $pyObj);

        }

        int tmp = code.getLocal("[org/python/core/PyObject");

        code.iconst(n);

        code.anewarray(code.pool.Class("org/python/core/PyObject"));

        code.astore(tmp);

        Hashtable upTbl = scope.up.tbl;

        for (int i = 0; i < n; i++) {

            code.aload(tmp);

            code.iconst(i);

            loadFrame();

            for (int j = 1; j < scope.distance; j++) {

                loadf_back();

            }

            SymInfo symInfo = (SymInfo) upTbl.get(scope.freevars.elementAt(i));

            code.iconst(symInfo.env_index);

            code.invokevirtual(getclosure);

            code.aastore();

        }

        code.aload(tmp);

        code.freeLocal(tmp);

        return true;

    }

    int f_globals, PyFunction_init, PyFunction_closure_init;

    public Object visitFunctionDef(FunctionDef node) throws Exception {

        String name = getName(node.name);

        setline(node);

        code.new_(code.pool.Class("org/python/core/PyFunction"));

        code.dup();

        loadFrame();

        if (mrefs.f_globals == 0) {

            mrefs.f_globals = code.pool.Fieldref("org/python/core/PyFrame", "f_globals", $pyObj);

        }

        code.getfield(mrefs.f_globals);

        ScopeInfo scope = module.getScopeInfo(node);

        makeArray(scope.ac.getDefaults());

        scope.setup_closure();

        scope.dump();

        module.PyCode(new Suite(node.body, node), name, true, className, false, false, node.beginLine, scope, cflags)

                .get(code);

        getDocString(node.body);

        if (!makeClosure(scope)) {

            if (mrefs.PyFunction_init == 0) {

                mrefs.PyFunction_init = code.pool.Methodref("org/python/core/PyFunction", "<init>", "(" + $pyObj

                        + $pyObjArr + $pyCode + $pyObj + ")V");

            }

            code.invokespecial(mrefs.PyFunction_init);

        } else {

            if (mrefs.PyFunction_closure_init == 0) {

                mrefs.PyFunction_closure_init = code.pool.Methodref("org/python/core/PyFunction", "<init>", "("

                        + $pyObj + $pyObjArr + $pyCode + $pyObj + $pyObjArr + ")V");

            }

            code.invokespecial(mrefs.PyFunction_closure_init);

        }

        set(new Name(node.name, Name.Store, node));

        return null;

    }

    public int printResult;

    public Object visitExpr(Expr node) throws Exception {

        setline(node);

        visit(node.value);

        if (print_results) {

            if (mrefs.printResult == 0) {

                mrefs.printResult = code.pool.Methodref("org/python/core/Py", "printResult", "(" + $pyObj + ")V");

            }

            code.invokestatic(mrefs.printResult);

        } else {

            code.pop();

        }

        return null;

    }

    public Object visitAssign(Assign node) throws Exception {

        setline(node);

        visit(node.value);

        if (node.targets.length == 1) {

            set(node.targets[0]);

            return null;

        }

        int tmp = storeTop();

        for (int i = node.targets.length - 1; i >= 0; i--) {

            set(node.targets[i], tmp);

        }

        code.freeLocal(tmp);

        return null;

    }

    public int print1, print2, print3, print4, print5, print6;

    public Object visitPrint(Print node) throws Exception {

        setline(node);

        int tmp = -1;

        int printcomma, printlnv, println;

        if (node.dest != null) {

            visit(node.dest);

            tmp = storeTop();

            if (mrefs.print4 == 0) {

                mrefs.print4 = pool.Methodref("org/python/core/Py", "printComma", "(" + $pyObj + $pyObj + ")V");

            }

            printcomma = mrefs.print4;

            if (mrefs.print5 == 0) {

                mrefs.print5 = pool.Methodref("org/python/core/Py", "println", "(" + $pyObj + $pyObj + ")V");

            }

            println = mrefs.print5;

            if (mrefs.print6 == 0) {

                mrefs.print6 = pool.Methodref("org/python/core/Py", "printlnv", "(" + $pyObj + ")V");

            }

            printlnv = mrefs.print6;

        } else {

            if (mrefs.print1 == 0) {

                mrefs.print1 = pool.Methodref("org/python/core/Py", "printComma", "(" + $pyObj + ")V");

            }

            printcomma = mrefs.print1;

            if (mrefs.print2 == 0) {

                mrefs.print2 = pool.Methodref("org/python/core/Py", "println", "(" + $pyObj + ")V");

            }

            println = mrefs.print2;

            if (mrefs.print3 == 0) {

                mrefs.print3 = pool.Methodref("org/python/core/Py", "println", "()V");

            }

            printlnv = mrefs.print3;

        }

        if (node.values == null || node.values.length == 0) {

            if (node.dest != null)

                code.aload(tmp);

            code.invokestatic(printlnv);

        } else {

            for (int i = 0; i < node.values.length; i++) {

                if (node.dest != null)

                    code.aload(tmp);

                visit(node.values[i]);

                if (node.nl && i == node.values.length - 1) {

                    code.invokestatic(println);

                } else {

                    code.invokestatic(printcomma);

                }

            }

        }

        if (node.dest != null)

            code.freeLocal(tmp);

        return null;

    }

    public Object visitDelete(Delete node) throws Exception {

        setline(node);

        traverse(node);

        return null;

    }

    public Object visitPass(Pass node) throws Exception {

        setline(node);

        return null;

    }

    public Object visitBreak(Break node) throws Exception {

        //setline(node); Not needed here...

        if (breakLabels.empty()) {

            throw new ParseException("'break' outside loop", node);

        }

        doFinallysDownTo(bcfLevel);

        code.goto_((Label) breakLabels.peek());

        return null;

    }

    public Object visitContinue(Continue node) throws Exception {

        //setline(node); Not needed here...

        if (continueLabels.empty()) {

            throw new ParseException("'continue' not properly in loop", node);

        }

        doFinallysDownTo(bcfLevel);

        code.goto_((Label) continueLabels.peek());

        return Exit;

    }

    int yield_count = 0;

    int f_savedlocals;

    public Object visitYield(Yield node) throws Exception {

        setline(node);

        if (!fast_locals) {

            throw new ParseException("'yield' outside function", node);

        }

        if (inFinallyBody()) {

            throw new ParseException("'yield' not allowed in a 'try' " + "block with a 'finally' clause", node);

        }

        saveLocals();

        visit(node.value);

        setLastI(++yield_count);

        code.areturn();

        Label restart = code.getLabel();

        yields.addElement(restart);

        restart.setPosition();

        restoreLocals();

        return null;

    }

    private boolean inFinallyBody() {

        for (int i = 0; i < exceptionHandlers.size(); ++i) {

            ExceptionHandler handler = (ExceptionHandler) exceptionHandlers.elementAt(i);

            if (handler.isFinallyHandler()) {

                return true;

            }

        }

        return false;

    }

    private void restoreLocals() throws Exception {

        endExceptionHandlers();

        Vector v = code.getActiveLocals();

        loadFrame();

        if (mrefs.f_savedlocals == 0) {

            mrefs.f_savedlocals = code.pool.Fieldref("org/python/core/PyFrame", "f_savedlocals", "[Ljava/lang/Object;");

        }

        code.getfield(mrefs.f_savedlocals);

        int locals = code.getLocal("[java/lang/Object");

        code.astore(locals);

        for (int i = 0; i < v.size(); i++) {

            String type = (String) v.elementAt(i);

            if (type == null)

                continue;

            code.aload(locals);

            code.iconst(i);

            code.aaload();

            code.checkcast(code.pool.Class(type));

            code.astore(i);

        }

        code.freeLocal(locals);

        restartExceptionHandlers();

    }

    /**

     *  Close all the open exception handler ranges.  This should be paired

     *  with restartExceptionHandlers to delimit internal code that

     *  shouldn't be handled by user handlers.  This allows us to set

     *  variables without the verifier thinking we might jump out of our

     *  handling with an exception.

     */

    private void endExceptionHandlers() {

        Label end = code.getLabelAtPosition();

        for (int i = 0; i < exceptionHandlers.size(); ++i) {

            ExceptionHandler handler = (ExceptionHandler) exceptionHandlers.elementAt(i);

            handler.exceptionEnds.addElement(end);

        }

    }

    private void restartExceptionHandlers() {

        Label start = code.getLabelAtPosition();

        for (int i = 0; i < exceptionHandlers.size(); ++i) {

            ExceptionHandler handler = (ExceptionHandler) exceptionHandlers.elementAt(i);

            handler.exceptionStarts.addElement(start);

        }

    }

    private void saveLocals() throws Exception {

        Vector v = code.getActiveLocals();

        //System.out.println("bs:" + bs);

        code.iconst(v.size());

        //code.anewarray(code.pool.Class("org/python/core/PyObject"));

        code.anewarray(code.pool.Class("java/lang/Object"));

        int locals = code.getLocal("[java/lang/Object");

        code.astore(locals);

        for (int i = 0; i < v.size(); i++) {

            String type = (String) v.elementAt(i);

            if (type == null)

                continue;

            code.aload(locals);

            code.iconst(i);

            //code.checkcast(code.pool.Class("java/lang/Object"));

            if (i == 2222) {

                code.aconst_null();

            } else

                code.aload(i);

            code.aastore();

        }

        if (mrefs.f_savedlocals == 0) {

            mrefs.f_savedlocals = code.pool.Fieldref("org/python/core/PyFrame", "f_savedlocals", "[Ljava/lang/Object;");

        }

        loadFrame();

        code.aload(locals);

        code.putfield(mrefs.f_savedlocals);

        code.freeLocal(locals);

    }

    public Object visitReturn(Return node) throws Exception {

        return visitReturn(node, false);

    }

    public Object visitReturn(Return node, boolean inEval) throws Exception {

        setline(node);

        if (!inEval && !fast_locals) {

            throw new ParseException("'return' outside function", node);

        }

        int tmp = 0;

        if (node.value != null) {

            if (my_scope.generator)

                throw new ParseException("'return' with argument " + "inside generator", node);

            visit(node.value);

            tmp = code.getReturnLocal();

            code.astore(tmp);

        }

        doFinallysDownTo(0);

        setLastI(-1);

        if (node.value != null) {

            code.aload(tmp);

        } else {

            getNone();

        }

        code.areturn();

        return Exit;

    }

    public int makeException0, makeException1, makeException2, makeException3;

    public Object visitRaise(Raise node) throws Exception {

        setline(node);

        traverse(node);

        if (node.type == null) {

            if (mrefs.makeException0 == 0) {

                mrefs.makeException0 = code.pool.Methodref("org/python/core/Py", "makeException", "()" + $pyExc);

            }

            code.invokestatic(mrefs.makeException0);

        } else if (node.inst == null) {

            if (mrefs.makeException1 == 0) {

                mrefs.makeException1 = code.pool.Methodref("org/python/core/Py", "makeException", "(" + $pyObj + ")"

                        + $pyExc);

            }

            code.invokestatic(mrefs.makeException1);

        } else if (node.tback == null) {

            if (mrefs.makeException2 == 0) {

                mrefs.makeException2 = code.pool.Methodref("org/python/core/Py", "makeException", "(" + $pyObj + $pyObj

                        + ")" + $pyExc);

            }

            code.invokestatic(mrefs.makeException2);

        } else {

            if (mrefs.makeException3 == 0) {

                mrefs.makeException3 = code.pool.Methodref("org/python/core/Py", "makeException", "(" + $pyObj + $pyObj

                        + $pyObj + ")" + $pyExc);

            }

            code.invokestatic(mrefs.makeException3);

        }

        code.athrow();

        return Exit;

    }

    public int importOne, importOneAs;

    public Object visitImport(Import node) throws Exception {

        setline(node);

        for (int i = 0; i < node.names.length; i++) {

            String asname = null;

            if (node.names[i].asname != null) {

                String name = node.names[i].name;

                asname = node.names[i].asname;

                code.ldc(name);

                loadFrame();

                if (mrefs.importOneAs == 0) {

                    mrefs.importOneAs = code.pool.Methodref("org/python/core/imp", "importOneAs", "(" + $str + $pyFrame

                            + ")" + $pyObj);

                }

                code.invokestatic(mrefs.importOneAs);

            } else {

                String name = node.names[i].name;